// @ts-nocheck

// DEFLATE is a complex format; to read this code, you should probably check the RFC first:
// https://tools.ietf.org/html/rfc1951
// You may also wish to take a look at the guide I made about this program:
// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad
// Some of the following code is similar to that of UZIP.js:
// https://github.com/photopea/UZIP.js
// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.
// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint
// is better for memory in most engines (I *think*).

// aliases for shorter compressed code (most minifers don't do this)
var u8 = Uint8Array,
  u16 = Uint16Array,
  i32 = Int32Array
// fixed length extra bits
var fleb = new u8([
  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0,
  /* unused */ 0, 0, /* impossible */ 0
])
// fixed distance extra bits
var fdeb = new u8([
  0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13,
  /* unused */ 0, 0
])
// code length index map
var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15])
// get base, reverse index map from extra bits
var freb = function (eb, start) {
  var b = new u16(31)
  for (var i = 0; i < 31; ++i) {
    b[i] = start += 1 << eb[i - 1]
  }
  // numbers here are at max 18 bits
  var r = new i32(b[30])
  for (var i = 1; i < 30; ++i) {
    for (var j = b[i]; j < b[i + 1]; ++j) {
      r[j] = ((j - b[i]) << 5) | i
    }
  }
  return { b: b, r: r }
}
var _a = freb(fleb, 2),
  fl = _a.b,
  revfl = _a.r
// we can ignore the fact that the other numbers are wrong; they never happen anyway
;(fl[28] = 258), (revfl[258] = 28)
var _b = freb(fdeb, 0),
  fd = _b.b,
  revfd = _b.r
// map of value to reverse (assuming 16 bits)
var rev = new u16(32768)
for (var i = 0; i < 32768; ++i) {
  // reverse table algorithm from SO
  var x = ((i & 0xaaaa) >> 1) | ((i & 0x5555) << 1)
  x = ((x & 0xcccc) >> 2) | ((x & 0x3333) << 2)
  x = ((x & 0xf0f0) >> 4) | ((x & 0x0f0f) << 4)
  rev[i] = (((x & 0xff00) >> 8) | ((x & 0x00ff) << 8)) >> 1
}
// create huffman tree from u8 "map": index -> code length for code index
// mb (max bits) must be at most 15
// TODO: optimize/split up?
var hMap = function (cd, mb, r) {
  var s = cd.length
  // index
  var i = 0
  // u16 "map": index -> # of codes with bit length = index
  var l = new u16(mb)
  // length of cd must be 288 (total # of codes)
  for (; i < s; ++i) {
    if (cd[i]) ++l[cd[i] - 1]
  }
  // u16 "map": index -> minimum code for bit length = index
  var le = new u16(mb)
  for (i = 1; i < mb; ++i) {
    le[i] = (le[i - 1] + l[i - 1]) << 1
  }
  var co
  if (r) {
    // u16 "map": index -> number of actual bits, symbol for code
    co = new u16(1 << mb)
    // bits to remove for reverser
    var rvb = 15 - mb
    for (i = 0; i < s; ++i) {
      // ignore 0 lengths
      if (cd[i]) {
        // num encoding both symbol and bits read
        var sv = (i << 4) | cd[i]
        // free bits
        var r_1 = mb - cd[i]
        // start value
        var v = le[cd[i] - 1]++ << r_1
        // m is end value
        for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
          // every 16 bit value starting with the code yields the same result
          co[rev[v] >> rvb] = sv
        }
      }
    }
  } else {
    co = new u16(s)
    for (i = 0; i < s; ++i) {
      if (cd[i]) {
        co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i])
      }
    }
  }
  return co
}
// fixed length tree
var flt = new u8(288)
for (var i = 0; i < 144; ++i) flt[i] = 8
for (var i = 144; i < 256; ++i) flt[i] = 9
for (var i = 256; i < 280; ++i) flt[i] = 7
for (var i = 280; i < 288; ++i) flt[i] = 8
// fixed distance tree
var fdt = new u8(32)
for (var i = 0; i < 32; ++i) fdt[i] = 5
// fixed length map
var flm = /*#__PURE__*/ hMap(flt, 9, 0),
  flrm = /*#__PURE__*/ hMap(flt, 9, 1)
// fixed distance map
var fdm = /*#__PURE__*/ hMap(fdt, 5, 0),
  fdrm = /*#__PURE__*/ hMap(fdt, 5, 1)
// find max of array
var max = function (a) {
  var m = a[0]
  for (var i = 1; i < a.length; ++i) {
    if (a[i] > m) m = a[i]
  }
  return m
}
// read d, starting at bit p and mask with m
var bits = function (d, p, m) {
  var o = (p / 8) | 0
  return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m
}
// read d, starting at bit p continuing for at least 16 bits
var bits16 = function (d, p) {
  var o = (p / 8) | 0
  return (d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7)
}
// get end of byte
var shft = function (p) {
  return ((p + 7) / 8) | 0
}
// typed array slice - allows garbage collector to free original reference,
// while being more compatible than .slice
var slc = function (v, s, e) {
  if (s == null || s < 0) s = 0
  if (e == null || e > v.length) e = v.length
  // can't use .constructor in case user-supplied
  var n = new u8(e - s)
  n.set(v.subarray(s, e))
  return n
}
// error codes
var ec = [
  'unexpected EOF',
  'invalid block type',
  'invalid length/literal',
  'invalid distance',
  'stream finished',
  'no stream handler',
  ,
  'no callback',
  'invalid UTF-8 data',
  'extra field too long',
  'date not in range 1980-2099',
  'filename too long',
  'stream finishing',
  'invalid zip data'
  // determined by unknown compression method
]
var err = function (ind, msg, nt) {
  var e = new Error(msg || ec[ind])
  e.code = ind
  if (Error.captureStackTrace) Error.captureStackTrace(e, err)
  if (!nt) throw e
  return e
}
// expands raw DEFLATE data
var inflt = function (dat, st, buf, dict) {
  // source length       dict length
  var sl = dat.length,
    dl = dict ? dict.length : 0
  if (!sl || (st.f && !st.l)) return buf || new u8(0)
  // have to estimate size
  var noBuf = !buf || st.i != 2
  // no state
  var noSt = st.i
  // Assumes roughly 33% compression ratio average
  if (!buf) buf = new u8(sl * 3)
  // ensure buffer can fit at least l elements
  var cbuf = function (l) {
    var bl = buf.length
    // need to increase size to fit
    if (l > bl) {
      // Double or set to necessary, whichever is greater
      var nbuf = new u8(Math.max(bl * 2, l))
      nbuf.set(buf)
      buf = nbuf
    }
  }
  //  last chunk         bitpos           bytes
  var final = st.f || 0,
    pos = st.p || 0,
    bt = st.b || 0,
    lm = st.l,
    dm = st.d,
    lbt = st.m,
    dbt = st.n
  // total bits
  var tbts = sl * 8
  do {
    if (!lm) {
      // BFINAL - this is only 1 when last chunk is next
      final = bits(dat, pos, 1)
      // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
      var type = bits(dat, pos + 1, 3)
      pos += 3
      if (!type) {
        // go to end of byte boundary
        var s = shft(pos) + 4,
          l = dat[s - 4] | (dat[s - 3] << 8),
          t = s + l
        if (t > sl) {
          if (noSt) err(0)
          break
        }
        // ensure size
        if (noBuf) cbuf(bt + l)
        // Copy over uncompressed data
        buf.set(dat.subarray(s, t), bt)
        // Get new bitpos, update byte count
        ;(st.b = bt += l), (st.p = pos = t * 8), (st.f = final)
        continue
      } else if (type == 1) (lm = flrm), (dm = fdrm), (lbt = 9), (dbt = 5)
      else if (type == 2) {
        //  literal                            lengths
        var hLit = bits(dat, pos, 31) + 257,
          hcLen = bits(dat, pos + 10, 15) + 4
        var tl = hLit + bits(dat, pos + 5, 31) + 1
        pos += 14
        // length+distance tree
        var ldt = new u8(tl)
        // code length tree
        var clt = new u8(19)
        for (var i = 0; i < hcLen; ++i) {
          // use index map to get real code
          clt[clim[i]] = bits(dat, pos + i * 3, 7)
        }
        pos += hcLen * 3
        // code lengths bits
        var clb = max(clt),
          clbmsk = (1 << clb) - 1
        // code lengths map
        var clm = hMap(clt, clb, 1)
        for (var i = 0; i < tl; ) {
          var r = clm[bits(dat, pos, clbmsk)]
          // bits read
          pos += r & 15
          // symbol
          var s = r >> 4
          // code length to copy
          if (s < 16) {
            ldt[i++] = s
          } else {
            //  copy   count
            var c = 0,
              n = 0
            if (s == 16) (n = 3 + bits(dat, pos, 3)), (pos += 2), (c = ldt[i - 1])
            else if (s == 17) (n = 3 + bits(dat, pos, 7)), (pos += 3)
            else if (s == 18) (n = 11 + bits(dat, pos, 127)), (pos += 7)
            while (n--) ldt[i++] = c
          }
        }
        //    length tree                 distance tree
        var lt = ldt.subarray(0, hLit),
          dt = ldt.subarray(hLit)
        // max length bits
        lbt = max(lt)
        // max dist bits
        dbt = max(dt)
        lm = hMap(lt, lbt, 1)
        dm = hMap(dt, dbt, 1)
      } else err(1)
      if (pos > tbts) {
        if (noSt) err(0)
        break
      }
    }
    // Make sure the buffer can hold this + the largest possible addition
    // Maximum chunk size (practically, theoretically infinite) is 2^17
    if (noBuf) cbuf(bt + 131072)
    var lms = (1 << lbt) - 1,
      dms = (1 << dbt) - 1
    var lpos = pos
    for (; ; lpos = pos) {
      // bits read, code
      var c = lm[bits16(dat, pos) & lms],
        sym = c >> 4
      pos += c & 15
      if (pos > tbts) {
        if (noSt) err(0)
        break
      }
      if (!c) err(2)
      if (sym < 256) buf[bt++] = sym
      else if (sym == 256) {
        ;(lpos = pos), (lm = null)
        break
      } else {
        var add = sym - 254
        // no extra bits needed if less
        if (sym > 264) {
          // index
          var i = sym - 257,
            b = fleb[i]
          add = bits(dat, pos, (1 << b) - 1) + fl[i]
          pos += b
        }
        // dist
        var d = dm[bits16(dat, pos) & dms],
          dsym = d >> 4
        if (!d) err(3)
        pos += d & 15
        var dt = fd[dsym]
        if (dsym > 3) {
          var b = fdeb[dsym]
          ;(dt += bits16(dat, pos) & ((1 << b) - 1)), (pos += b)
        }
        if (pos > tbts) {
          if (noSt) err(0)
          break
        }
        if (noBuf) cbuf(bt + 131072)
        var end = bt + add
        if (bt < dt) {
          var shift = dl - dt,
            dend = Math.min(dt, end)
          if (shift + bt < 0) err(3)
          for (; bt < dend; ++bt) buf[bt] = dict[shift + bt]
        }
        for (; bt < end; bt += 4) {
          buf[bt] = buf[bt - dt]
          buf[bt + 1] = buf[bt + 1 - dt]
          buf[bt + 2] = buf[bt + 2 - dt]
          buf[bt + 3] = buf[bt + 3 - dt]
        }
        bt = end
      }
    }
    ;(st.l = lm), (st.p = lpos), (st.b = bt), (st.f = final)
    if (lm) (final = 1), (st.m = lbt), (st.d = dm), (st.n = dbt)
  } while (!final)
  return bt == buf.length ? buf : slc(buf, 0, bt)
}
// starting at p, write the minimum number of bits that can hold v to d
var wbits = function (d, p, v) {
  v <<= p & 7
  var o = (p / 8) | 0
  d[o] |= v
  d[o + 1] |= v >> 8
}
// starting at p, write the minimum number of bits (>8) that can hold v to d
var wbits16 = function (d, p, v) {
  v <<= p & 7
  var o = (p / 8) | 0
  d[o] |= v
  d[o + 1] |= v >> 8
  d[o + 2] |= v >> 16
}
// creates code lengths from a frequency table
var hTree = function (d, mb) {
  // Need extra info to make a tree
  var t = []
  for (var i = 0; i < d.length; ++i) {
    if (d[i]) t.push({ s: i, f: d[i] })
  }
  var s = t.length
  var t2 = t.slice()
  if (!s) return { t: et, l: 0 }
  if (s == 1) {
    var v = new u8(t[0].s + 1)
    v[t[0].s] = 1
    return { t: v, l: 1 }
  }
  t.sort(function (a, b) {
    return a.f - b.f
  })
  // after i2 reaches last ind, will be stopped
  // freq must be greater than largest possible number of symbols
  t.push({ s: -1, f: 25001 })
  var l = t[0],
    r = t[1],
    i0 = 0,
    i1 = 1,
    i2 = 2
  t[0] = { s: -1, f: l.f + r.f, l: l, r: r }
  // efficient algorithm from UZIP.js
  // i0 is lookbehind, i2 is lookahead - after processing two low-freq
  // symbols that combined have high freq, will start processing i2 (high-freq,
  // non-composite) symbols instead
  // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/
  while (i1 != s - 1) {
    l = t[t[i0].f < t[i2].f ? i0++ : i2++]
    r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++]
    t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r }
  }
  var maxSym = t2[0].s
  for (var i = 1; i < s; ++i) {
    if (t2[i].s > maxSym) maxSym = t2[i].s
  }
  // code lengths
  var tr = new u16(maxSym + 1)
  // max bits in tree
  var mbt = ln(t[i1 - 1], tr, 0)
  if (mbt > mb) {
    // more algorithms from UZIP.js
    // TODO: find out how this code works (debt)
    //  ind    debt
    var i = 0,
      dt = 0
    //    left            cost
    var lft = mbt - mb,
      cst = 1 << lft
    t2.sort(function (a, b) {
      return tr[b.s] - tr[a.s] || a.f - b.f
    })
    for (; i < s; ++i) {
      var i2_1 = t2[i].s
      if (tr[i2_1] > mb) {
        dt += cst - (1 << (mbt - tr[i2_1]))
        tr[i2_1] = mb
      } else break
    }
    dt >>= lft
    while (dt > 0) {
      var i2_2 = t2[i].s
      if (tr[i2_2] < mb) dt -= 1 << (mb - tr[i2_2]++ - 1)
      else ++i
    }
    for (; i >= 0 && dt; --i) {
      var i2_3 = t2[i].s
      if (tr[i2_3] == mb) {
        --tr[i2_3]
        ++dt
      }
    }
    mbt = mb
  }
  return { t: new u8(tr), l: mbt }
}
// get the max length and assign length codes
var ln = function (n, l, d) {
  return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : (l[n.s] = d)
}
// length codes generation
var lc = function (c) {
  var s = c.length
  // Note that the semicolon was intentional
  while (s && !c[--s]);
  var cl = new u16(++s)
  //  ind      num         streak
  var cli = 0,
    cln = c[0],
    cls = 1
  var w = function (v) {
    cl[cli++] = v
  }
  for (var i = 1; i <= s; ++i) {
    if (c[i] == cln && i != s) ++cls
    else {
      if (!cln && cls > 2) {
        for (; cls > 138; cls -= 138) w(32754)
        if (cls > 2) {
          w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305)
          cls = 0
        }
      } else if (cls > 3) {
        w(cln), --cls
        for (; cls > 6; cls -= 6) w(8304)
        if (cls > 2) w(((cls - 3) << 5) | 8208), (cls = 0)
      }
      while (cls--) w(cln)
      cls = 1
      cln = c[i]
    }
  }
  return { c: cl.subarray(0, cli), n: s }
}
// calculate the length of output from tree, code lengths
var clen = function (cf, cl) {
  var l = 0
  for (var i = 0; i < cl.length; ++i) l += cf[i] * cl[i]
  return l
}
// writes a fixed block
// returns the new bit pos
var wfblk = function (out, pos, dat) {
  // no need to write 00 as type: TypedArray defaults to 0
  var s = dat.length
  var o = shft(pos + 2)
  out[o] = s & 255
  out[o + 1] = s >> 8
  out[o + 2] = out[o] ^ 255
  out[o + 3] = out[o + 1] ^ 255
  for (var i = 0; i < s; ++i) out[o + i + 4] = dat[i]
  return (o + 4 + s) * 8
}
// writes a block
var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
  wbits(out, p++, final)
  ++lf[256]
  var _a = hTree(lf, 15),
    dlt = _a.t,
    mlb = _a.l
  var _b = hTree(df, 15),
    ddt = _b.t,
    mdb = _b.l
  var _c = lc(dlt),
    lclt = _c.c,
    nlc = _c.n
  var _d = lc(ddt),
    lcdt = _d.c,
    ndc = _d.n
  var lcfreq = new u16(19)
  for (var i = 0; i < lclt.length; ++i) ++lcfreq[lclt[i] & 31]
  for (var i = 0; i < lcdt.length; ++i) ++lcfreq[lcdt[i] & 31]
  var _e = hTree(lcfreq, 7),
    lct = _e.t,
    mlcb = _e.l
  var nlcc = 19
  for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc);
  var flen = (bl + 5) << 3
  var ftlen = clen(lf, flt) + clen(df, fdt) + eb
  var dtlen =
    clen(lf, dlt) +
    clen(df, ddt) +
    eb +
    14 +
    3 * nlcc +
    clen(lcfreq, lct) +
    2 * lcfreq[16] +
    3 * lcfreq[17] +
    7 * lcfreq[18]
  if (bs >= 0 && flen <= ftlen && flen <= dtlen) return wfblk(out, p, dat.subarray(bs, bs + bl))
  var lm, ll, dm, dl
  wbits(out, p, 1 + (dtlen < ftlen)), (p += 2)
  if (dtlen < ftlen) {
    ;(lm = hMap(dlt, mlb, 0)), (ll = dlt), (dm = hMap(ddt, mdb, 0)), (dl = ddt)
    var llm = hMap(lct, mlcb, 0)
    wbits(out, p, nlc - 257)
    wbits(out, p + 5, ndc - 1)
    wbits(out, p + 10, nlcc - 4)
    p += 14
    for (var i = 0; i < nlcc; ++i) wbits(out, p + 3 * i, lct[clim[i]])
    p += 3 * nlcc
    var lcts = [lclt, lcdt]
    for (var it = 0; it < 2; ++it) {
      var clct = lcts[it]
      for (var i = 0; i < clct.length; ++i) {
        var len = clct[i] & 31
        wbits(out, p, llm[len]), (p += lct[len])
        if (len > 15) wbits(out, p, (clct[i] >> 5) & 127), (p += clct[i] >> 12)
      }
    }
  } else {
    ;(lm = flm), (ll = flt), (dm = fdm), (dl = fdt)
  }
  for (var i = 0; i < li; ++i) {
    var sym = syms[i]
    if (sym > 255) {
      var len = (sym >> 18) & 31
      wbits16(out, p, lm[len + 257]), (p += ll[len + 257])
      if (len > 7) wbits(out, p, (sym >> 23) & 31), (p += fleb[len])
      var dst = sym & 31
      wbits16(out, p, dm[dst]), (p += dl[dst])
      if (dst > 3) wbits16(out, p, (sym >> 5) & 8191), (p += fdeb[dst])
    } else {
      wbits16(out, p, lm[sym]), (p += ll[sym])
    }
  }
  wbits16(out, p, lm[256])
  return p + ll[256]
}
// deflate options (nice << 13) | chain
var deo = /*#__PURE__*/ new i32([
  65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632
])
// empty
var et = /*#__PURE__*/ new u8(0)
// compresses data into a raw DEFLATE buffer
var dflt = function (dat, lvl, plvl, pre, post, st) {
  var s = st.z || dat.length
  var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post)
  // writing to this writes to the output buffer
  var w = o.subarray(pre, o.length - post)
  var lst = st.l
  var pos = (st.r || 0) & 7
  if (lvl) {
    if (pos) w[0] = st.r >> 3
    var opt = deo[lvl - 1]
    var n = opt >> 13,
      c = opt & 8191
    var msk_1 = (1 << plvl) - 1
    //    prev 2-byte val map    curr 2-byte val map
    var prev = st.p || new u16(32768),
      head = st.h || new u16(msk_1 + 1)
    var bs1_1 = Math.ceil(plvl / 3),
      bs2_1 = 2 * bs1_1
    var hsh = function (i) {
      return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1
    }
    // 24576 is an arbitrary number of maximum symbols per block
    // 424 buffer for last block
    var syms = new i32(25000)
    // length/literal freq   distance freq
    var lf = new u16(288),
      df = new u16(32)
    //  l/lcnt  exbits  index          l/lind  waitdx          blkpos
    var lc_1 = 0,
      eb = 0,
      i = st.i || 0,
      li = 0,
      wi = st.w || 0,
      bs = 0
    for (; i + 2 < s; ++i) {
      // hash value
      var hv = hsh(i)
      // index mod 32768    previous index mod
      var imod = i & 32767,
        pimod = head[hv]
      prev[imod] = pimod
      head[hv] = imod
      // We always should modify head and prev, but only add symbols if
      // this data is not yet processed ("wait" for wait index)
      if (wi <= i) {
        // bytes remaining
        var rem = s - i
        if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {
          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos)
          ;(li = lc_1 = eb = 0), (bs = i)
          for (var j = 0; j < 286; ++j) lf[j] = 0
          for (var j = 0; j < 30; ++j) df[j] = 0
        }
        //  len    dist   chain
        var l = 2,
          d = 0,
          ch_1 = c,
          dif = (imod - pimod) & 32767
        if (rem > 2 && hv == hsh(i - dif)) {
          var maxn = Math.min(n, rem) - 1
          var maxd = Math.min(32767, i)
          // max possible length
          // not capped at dif because decompressors implement "rolling" index population
          var ml = Math.min(258, rem)
          while (dif <= maxd && --ch_1 && imod != pimod) {
            if (dat[i + l] == dat[i + l - dif]) {
              var nl = 0
              for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl);
              if (nl > l) {
                ;(l = nl), (d = dif)
                // break out early when we reach "nice" (we are satisfied enough)
                if (nl > maxn) break
                // now, find the rarest 2-byte sequence within this
                // length of literals and search for that instead.
                // Much faster than just using the start
                var mmd = Math.min(dif, nl - 2)
                var md = 0
                for (var j = 0; j < mmd; ++j) {
                  var ti = (i - dif + j) & 32767
                  var pti = prev[ti]
                  var cd = (ti - pti) & 32767
                  if (cd > md) (md = cd), (pimod = ti)
                }
              }
            }
            // check the previous match
            ;(imod = pimod), (pimod = prev[imod])
            dif += (imod - pimod) & 32767
          }
        }
        // d will be nonzero only when a match was found
        if (d) {
          // store both dist and len data in one int32
          // Make sure this is recognized as a len/dist with 28th bit (2^28)
          syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d]
          var lin = revfl[l] & 31,
            din = revfd[d] & 31
          eb += fleb[lin] + fdeb[din]
          ++lf[257 + lin]
          ++df[din]
          wi = i + l
          ++lc_1
        } else {
          syms[li++] = dat[i]
          ++lf[dat[i]]
        }
      }
    }
    for (i = Math.max(i, wi); i < s; ++i) {
      syms[li++] = dat[i]
      ++lf[dat[i]]
    }
    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos)
    if (!lst) {
      st.r = (pos & 7) | (w[(pos / 8) | 0] << 3)
      // shft(pos) now 1 less if pos & 7 != 0
      pos -= 7
      ;(st.h = head), (st.p = prev), (st.i = i), (st.w = wi)
    }
  } else {
    for (var i = st.w || 0; i < s + lst; i += 65535) {
      // end
      var e = i + 65535
      if (e >= s) {
        // write final block
        w[(pos / 8) | 0] = lst
        e = s
      }
      pos = wfblk(w, pos + 1, dat.subarray(i, e))
    }
    st.i = s
  }
  return slc(o, 0, pre + shft(pos) + post)
}
// Adler32
var adler = function () {
  var a = 1,
    b = 0
  return {
    p: function (d) {
      // closures have awful performance
      var n = a,
        m = b
      var l = d.length | 0
      for (var i = 0; i != l; ) {
        var e = Math.min(i + 2655, l)
        for (; i < e; ++i) m += n += d[i]
        ;(n = (n & 65535) + 15 * (n >> 16)), (m = (m & 65535) + 15 * (m >> 16))
      }
      ;(a = n), (b = m)
    },
    d: function () {
      ;(a %= 65521), (b %= 65521)
      return ((a & 255) << 24) | ((a & 0xff00) << 8) | ((b & 255) << 8) | (b >> 8)
    }
  }
}
// deflate with opts
var dopt = function (dat, opt, pre, post, st) {
  if (!st) {
    st = { l: 1 }
    if (opt.dictionary) {
      var dict = opt.dictionary.subarray(-32768)
      var newDat = new u8(dict.length + dat.length)
      newDat.set(dict)
      newDat.set(dat, dict.length)
      dat = newDat
      st.w = dict.length
    }
  }
  return dflt(
    dat,
    opt.level == null ? 6 : opt.level,
    opt.mem == null
      ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5)
      : 12 + opt.mem,
    pre,
    post,
    st
  )
}
// write bytes
var wbytes = function (d, b, v) {
  for (; v; ++b) (d[b] = v), (v >>>= 8)
}
// zlib header
var zlh = function (c, o) {
  var lv = o.level,
    fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2
  ;(c[0] = 120), (c[1] = (fl << 6) | (o.dictionary && 32))
  c[1] |= 31 - (((c[0] << 8) | c[1]) % 31)
  if (o.dictionary) {
    var h = adler()
    h.p(o.dictionary)
    wbytes(c, 2, h.d())
  }
}
// zlib start
var zls = function (d, dict) {
  if ((d[0] & 15) != 8 || d[0] >> 4 > 7 || ((d[0] << 8) | d[1]) % 31) err(6, 'invalid zlib data')
  if (((d[1] >> 5) & 1) == +!dict)
    err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary')
  return ((d[1] >> 3) & 4) + 2
}
/**
 * Compress data with Zlib
 * @param data The data to compress
 * @param opts The compression options
 * @returns The zlib-compressed version of the data
 */
function zlibSync(data, opts) {
  if (!opts) opts = {}
  var a = adler()
  a.p(data)
  var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4)
  return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d
}
/**
 * Expands Zlib data
 * @param data The data to decompress
 * @param opts The decompression options
 * @returns The decompressed version of the data
 */
function unzlibSync(data, opts) {
  return inflt(
    data.subarray(zls(data, opts && opts.dictionary), -4),
    { i: 2 },
    opts && opts.out,
    opts && opts.dictionary
  )
}
// text encoder
var te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder()
// text decoder
var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder()
// text decoder stream
var tds = 0
try {
  td.decode(et, { stream: true })
  tds = 1
} catch (e) {}
// decode UTF8
var dutf8 = function (d) {
  for (var r = '', i = 0; ; ) {
    var c = d[i++]
    var eb = (c > 127) + (c > 223) + (c > 239)
    if (i + eb > d.length) return { s: r, r: slc(d, i - 1) }
    if (!eb) r += String.fromCharCode(c)
    else if (eb == 3) {
      ;(c =
        (((c & 15) << 18) | ((d[i++] & 63) << 12) | ((d[i++] & 63) << 6) | (d[i++] & 63)) - 65536),
        (r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023)))
    } else if (eb & 1) r += String.fromCharCode(((c & 31) << 6) | (d[i++] & 63))
    else r += String.fromCharCode(((c & 15) << 12) | ((d[i++] & 63) << 6) | (d[i++] & 63))
  }
}
/**
 * Converts a string into a Uint8Array for use with compression/decompression methods
 * @param str The string to encode
 * @param latin1 Whether or not to interpret the data as Latin-1. This should
 *               not need to be true unless decoding a binary string.
 * @returns The string encoded in UTF-8/Latin-1 binary
 */
function strToU8(str, latin1) {
  if (latin1) {
    var ar_1 = new u8(str.length)
    for (var i = 0; i < str.length; ++i) ar_1[i] = str.charCodeAt(i)
    return ar_1
  }
  if (te) return te.encode(str)
  var l = str.length
  var ar = new u8(str.length + (str.length >> 1))
  var ai = 0
  var w = function (v) {
    ar[ai++] = v
  }
  for (var i = 0; i < l; ++i) {
    if (ai + 5 > ar.length) {
      var n = new u8(ai + 8 + ((l - i) << 1))
      n.set(ar)
      ar = n
    }
    var c = str.charCodeAt(i)
    if (c < 128 || latin1) w(c)
    else if (c < 2048) w(192 | (c >> 6)), w(128 | (c & 63))
    else if (c > 55295 && c < 57344)
      (c = (65536 + (c & (1023 << 10))) | (str.charCodeAt(++i) & 1023)),
        w(240 | (c >> 18)),
        w(128 | ((c >> 12) & 63)),
        w(128 | ((c >> 6) & 63)),
        w(128 | (c & 63))
    else w(224 | (c >> 12)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63))
  }
  return slc(ar, 0, ai)
}
/**
 * Converts a Uint8Array to a string
 * @param dat The data to decode to string
 * @param latin1 Whether or not to interpret the data as Latin-1. This should
 *               not need to be true unless encoding to binary string.
 * @returns The original UTF-8/Latin-1 string
 */
function strFromU8(dat, latin1) {
  if (latin1) {
    var r = ''
    for (var i = 0; i < dat.length; i += 16384)
      r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384))
    return r
  } else if (td) {
    return td.decode(dat)
  } else {
    var _a = dutf8(dat),
      s = _a.s,
      r = _a.r
    if (r.length) err(8)
    return s
  }
}

function debounce(fn, n = 100) {
  let handle
  return (...args) => {
    if (handle) clearTimeout(handle)
    handle = setTimeout(() => {
      fn(...args)
    }, n)
  }
}
function utoa(data) {
  const buffer = strToU8(data)
  const zipped = zlibSync(buffer, { level: 9 })
  const binary = strFromU8(zipped, true)
  return btoa(binary)
}
function atou(base64) {
  const binary = atob(base64)
  if (binary.startsWith('xÚ')) {
    const buffer = strToU8(binary, true)
    const unzipped = unzlibSync(buffer)
    return strFromU8(unzipped)
  }
  return decodeURIComponent(escape(binary))
}

export { atou, debounce, utoa }
